\section{R\'{e}f\'{e}rence du fichier process.h}
\label{process_8h}\index{process.h@{process.h}}
Centralise les fonctions appell\'{e}es par yacc/bison dans les diff\'{e}rentes r\`{e}gles. 

{\tt \#include \char`\"{}symbols.h\char`\"{}}\par
{\tt \#include \char`\"{}instructions.h\char`\"{}}\par


Graphe des d\'{e}pendances par inclusion de process.h:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=246pt]{process_8h__incl}
\end{center}
\end{figure}


Ce graphe montre quels fichiers incluent directement ou indirectement ce fichier:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=102pt]{process_8h__dep__incl}
\end{center}
\end{figure}
\subsection*{Affectations}
\begin{CompactItemize}
\item 
void {\bf process\-Aff} ({\bf Str\-Id} id, {\bf CSymbol} $\ast$val)
\begin{CompactList}\small\item\em Affectation d'une variable. \item\end{CompactList}\item 
void {\bf process\-Ref\-Aff} ({\bf CSymbol} $\ast$ref, {\bf CSymbol} $\ast$val)
\begin{CompactList}\small\item\em Affectation d'une variable par r\'{e}f\'{e}rence. \item\end{CompactList}\end{CompactItemize}
\subsection*{Op\'{e}rateurs binaires}
Ces fonctions prennent deux symboles (sous forme de pointeurs) en param\`{e}tres et retournent un pointeur vers symbole correspondant au r\'{e}sultat, ou NULL en cas d'erreur. \begin{CompactItemize}
\item 
{\bf CSymbol} $\ast$ {\bf process\-Op1Or} ({\bf CSymbol} $\ast$s)
\begin{CompactList}\small\item\em \char`\"{}Ou\char`\"{} paresseux, traitement du premier op\'{e}rande \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Op2Or} ({\bf CSymbol} $\ast$scible, {\bf CSymbol} $\ast$s)
\begin{CompactList}\small\item\em \char`\"{}Ou\char`\"{} paresseux, traitement du deuxi\`{e}me op\'{e}rande \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Op1And} ({\bf CSymbol} $\ast$s)
\begin{CompactList}\small\item\em \char`\"{}Et\char`\"{} paresseux, traitement du premier op\'{e}rande \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Op2And} ({\bf CSymbol} $\ast$scible, {\bf CSymbol} $\ast$s)
\begin{CompactList}\small\item\em \char`\"{}Et\char`\"{} paresseux, traitement du deuxi\`{e}me op\'{e}rande \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Add} ({\bf CSymbol} $\ast$s1, {\bf CSymbol} $\ast$s2)
\begin{CompactList}\small\item\em Additionne s1 et s2. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Sub} ({\bf CSymbol} $\ast$s1, {\bf CSymbol} $\ast$s2)
\begin{CompactList}\small\item\em Soustrait s2 \`{a} s1. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Mul} ({\bf CSymbol} $\ast$s1, {\bf CSymbol} $\ast$s2)
\begin{CompactList}\small\item\em Multiplie s1 par s2. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Div} ({\bf CSymbol} $\ast$s1, {\bf CSymbol} $\ast$s2)
\begin{CompactList}\small\item\em Divise s1 par s2. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Eql} ({\bf CSymbol} $\ast$s1, {\bf CSymbol} $\ast$s2)
\begin{CompactList}\small\item\em Calcule s1 == s2. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Grt} ({\bf CSymbol} $\ast$s1, {\bf CSymbol} $\ast$s2)
\begin{CompactList}\small\item\em Calcule s1 $>$ s2. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Low} ({\bf CSymbol} $\ast$s1, {\bf CSymbol} $\ast$s2)
\begin{CompactList}\small\item\em Calcule s1 $<$ s2. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Neq} ({\bf CSymbol} $\ast$s1, {\bf CSymbol} $\ast$s2)
\begin{CompactList}\small\item\em Calcule s1 != s2. \item\end{CompactList}\end{CompactItemize}
\subsection*{Op\'{e}rateurs unaires}
Ces fonctions prennent un symbole (sous forme de pointeur) en param\`{e}tre et retournent un pointeur vers symbole correspondant au r\'{e}sultat, ou NULL en cas d'erreur. \begin{CompactItemize}
\item 
{\bf CSymbol} $\ast$ {\bf process\-Ref} ({\bf Str\-Id} id)
\begin{CompactList}\small\item\em D\'{e}r\'{e}f\'{e}rence un symbole. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Deref} ({\bf CSymbol} $\ast$s)
\begin{CompactList}\small\item\em D\'{e}r\'{e}f\'{e}rence un symbole. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Minus} ({\bf CSymbol} $\ast$s)
\begin{CompactList}\small\item\em Calcule l'oppos\'{e} d'un symbole. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Not} ({\bf CSymbol} $\ast$s)
\begin{CompactList}\small\item\em Calcule la n\'{e}gation d'un symbole. \item\end{CompactList}\end{CompactItemize}
\subsection*{Gestion des constantes}
Ces fonctions permettent de passer d'une constante \`{a} un symbole. \begin{CompactItemize}
\item 
{\bf CSymbol} $\ast$ {\bf process\-Const\-Int} (int val)
\begin{CompactList}\small\item\em Cr\'{e}e un symbole pour une constante int. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Const\-Float} (float val)
\begin{CompactList}\small\item\em Cr\'{e}e un symbole pour une constante float. \item\end{CompactList}\item 
{\bf CSymbol} $\ast$ {\bf process\-Const\-Bool} (bool val)
\begin{CompactList}\small\item\em Cr\'{e}e un symbole pour une constante bool. \item\end{CompactList}\end{CompactItemize}
\subsection*{Fonctions d\'{e}stin\'{e}es aux branchements}
Elles sont appell\'{e}es directement ou indirectement par yacc/bison et permettent d'ajouter de g\'{e}rer les boucles et les blocs conditionnels, ajouter des instructions de type goto, ... \begin{CompactItemize}
\item 
void {\bf process\-Label\-New} ()
\begin{CompactList}\small\item\em Ajoute un label vers une nouvelle \'{e}tiquette et la retourne. \item\end{CompactList}\item 
void {\bf process\-Label} ({\bf Label\-Id} id)
\begin{CompactList}\small\item\em Ajoute un label vers une \'{e}tiquette donn\'{e}e. \item\end{CompactList}\item 
void {\bf process\-Goto\-New} ()
\begin{CompactList}\small\item\em Ajoute un goto vers une nouvelle \'{e}tiquette et la retourne. \item\end{CompactList}\item 
void {\bf process\-Goto} ({\bf Label\-Id} id)
\begin{CompactList}\small\item\em Ajoute un goto vers une \'{e}tiquette donn\'{e}e. \item\end{CompactList}\item 
void {\bf process\-If\-Not} ({\bf CSymbol} $\ast$s)
\begin{CompactList}\small\item\em Ajoute un branchement conditionnel IFNOT en testant s. \item\end{CompactList}\item 
void {\bf process\-Else} ()
\begin{CompactList}\small\item\em Ajoute les label et goto pour un else. \item\end{CompactList}\item 
void {\bf process\-Cond\-End} ()
\begin{CompactList}\small\item\em Ajoute les instructions \`{a} la fin d'une condition (IF THEN [ELSE]). \item\end{CompactList}\item 
void {\bf process\-Loop\-Start} ()
\begin{CompactList}\small\item\em Ajoute les instructions pour un d\'{e}but de boucle (WHILE/REPEAT). \item\end{CompactList}\item 
void {\bf process\-While\-Do\-End} ()
\begin{CompactList}\small\item\em Ajoute ;es innstructions de fin de WHILE DO. \item\end{CompactList}\item 
void {\bf process\-Repeat\-Until\-End} ({\bf CSymbol} $\ast$s)
\begin{CompactList}\small\item\em Ajoute les instructions de fin de REPEAT UNTIL. \item\end{CompactList}\end{CompactItemize}
\subsection*{Fonctions}
\begin{CompactItemize}
\item 
{\bf CSymbol} $\ast$ {\bf process\-Id} ({\bf Str\-Id} id)
\begin{CompactList}\small\item\em Retourne le symbole associ\'{e} \`{a} un id, g\`{e}re les erreurs. \item\end{CompactList}\end{CompactItemize}


\subsection{Description d\'{e}taill\'{e}e}
Centralise les fonctions appell\'{e}es par yacc/bison dans les diff\'{e}rentes r\`{e}gles. 

Ces fonctions r\'{e}alisent les op\'{e}rations n\'{e}cessaires dans chaque cas (ajout d'instructions, typage, ...). 

D\'{e}finition dans le fichier {\bf process.h}.

\subsection{Documentation des fonctions}
\index{process.h@{process.h}!processAdd@{processAdd}}
\index{processAdd@{processAdd}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Add ({\bf CSymbol} $\ast$ {\em s1}, {\bf CSymbol} $\ast$ {\em s2})}\label{process_8h_e8af96bde479c7ba1fb6583f852b407c}


Additionne s1 et s2. 



D\'{e}finition \`{a} la ligne 233 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert(), CSymbol::convert2(), decl\-Manager, error\-Warning(), CDecl\-Manager::free\-Symbol(), CType::get\-DRef(), CSymbol::get\-Type(), et T\_\-INT.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=233pt]{process_8h_e8af96bde479c7ba1fb6583f852b407c_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processAff@{processAff}}
\index{processAff@{processAff}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-Aff ({\bf Str\-Id} {\em id}, {\bf CSymbol} $\ast$ {\em val})}\label{process_8h_b033bda15a13693b1063523b6bf6eee9}


Affectation d'une variable. 



D\'{e}finition \`{a} la ligne 23 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert(), decl\-Manager, ERR\_\-UNDECLARED, error\-Error(), CDecl\-Manager::free\-Symbol(), CSymbol\-Stack::get\-Symbol\-From\-Str\-Id(), CSymbol::get\-Type(), CSymbol::is\-Valid(), et symbol\-Stack.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=250pt]{process_8h_b033bda15a13693b1063523b6bf6eee9_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processCondEnd@{processCondEnd}}
\index{processCondEnd@{processCondEnd}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-Cond\-End ()}\label{process_8h_7c4c49170645c53f3535406afcacbed3}


Ajoute les instructions \`{a} la fin d'une condition (IF THEN [ELSE]). 



D\'{e}finition \`{a} la ligne 796 du fichier process.cpp.

R\'{e}f\'{e}rences instr\-Queue, CInstr\-Queue::pop\-Label\-Id(), et process\-Label().

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=225pt]{process_8h_7c4c49170645c53f3535406afcacbed3_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processConstBool@{processConstBool}}
\index{processConstBool@{processConstBool}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Const\-Bool (bool {\em val})}\label{process_8h_54f587db7831f77e567ee642db60db95}


Cr\'{e}e un symbole pour une constante bool. 



D\'{e}finition \`{a} la ligne 753 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::get\-Id(), instr\-Queue, CInstr\-Queue::push\-Instr(), et T\_\-BOOL.

R\'{e}f\'{e}renc\'{e} par process\-Minus(), et yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=145pt]{process_8h_54f587db7831f77e567ee642db60db95_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processConstFloat@{processConstFloat}}
\index{processConstFloat@{processConstFloat}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Const\-Float (float {\em val})}\label{process_8h_784139565b2704a8bd81a9ce94b860bf}


Cr\'{e}e un symbole pour une constante float. 



D\'{e}finition \`{a} la ligne 745 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::get\-Id(), instr\-Queue, CInstr\-Queue::push\-Instr(), et T\_\-FLOAT.

R\'{e}f\'{e}renc\'{e} par process\-Minus(), et yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=146pt]{process_8h_784139565b2704a8bd81a9ce94b860bf_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processConstInt@{processConstInt}}
\index{processConstInt@{processConstInt}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Const\-Int (int {\em val})}\label{process_8h_9184c01d545302e275f7d633c5b796e1}


Cr\'{e}e un symbole pour une constante int. 



D\'{e}finition \`{a} la ligne 737 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::get\-Id(), instr\-Queue, CInstr\-Queue::push\-Instr(), et T\_\-INT.

R\'{e}f\'{e}renc\'{e} par process\-Minus(), et yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=141pt]{process_8h_9184c01d545302e275f7d633c5b796e1_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processDeref@{processDeref}}
\index{processDeref@{processDeref}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Deref ({\bf CSymbol} $\ast$ {\em s})}\label{process_8h_db0a792b420a47b1b92224893007debd}


D\'{e}r\'{e}f\'{e}rence un symbole. 



D\'{e}finition \`{a} la ligne 658 du fichier process.cpp.

R\'{e}f\'{e}rences decl\-Manager, ERR\_\-DEREF\_\-NONPOINTER, error\-Error(), CDecl\-Manager::free\-Symbol(), CType::get\-DRef(), CSymbol::get\-Id(), et CSymbol::get\-Type().

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=236pt]{process_8h_db0a792b420a47b1b92224893007debd_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processDiv@{processDiv}}
\index{processDiv@{processDiv}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Div ({\bf CSymbol} $\ast$ {\em s1}, {\bf CSymbol} $\ast$ {\em s2})}\label{process_8h_e5a9409176365e38e1c2e1ffc81a0657}


Divise s1 par s2. 



D\'{e}finition \`{a} la ligne 416 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert2(), decl\-Manager, ERR\_\-OP\_\-UNCOMPATIBLE, error\-Error(), CDecl\-Manager::free\-Symbol(), CType::get\-DRef(), CSymbol::get\-Id(), CSymbol::get\-Type(), INSTR\_\-DIV, instr\-Queue, CSymbol::is\-Valid(), et CInstr\-Queue::push\-Instr().

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=231pt]{process_8h_e5a9409176365e38e1c2e1ffc81a0657_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processElse@{processElse}}
\index{processElse@{processElse}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-Else ()}\label{process_8h_c35765e899e14bdacd0bb8f5365e7afd}


Ajoute les label et goto pour un else. 



D\'{e}finition \`{a} la ligne 787 du fichier process.cpp.

R\'{e}f\'{e}rences instr\-Queue, CInstr\-Queue::pop\-Label\-Id(), process\-Goto\-New(), et process\-Label().

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=309pt]{process_8h_c35765e899e14bdacd0bb8f5365e7afd_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processEql@{processEql}}
\index{processEql@{processEql}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Eql ({\bf CSymbol} $\ast$ {\em s1}, {\bf CSymbol} $\ast$ {\em s2})}\label{process_8h_409097c2fa8f126d3d71a4c500cbce1a}


Calcule s1 == s2. 



D\'{e}finition \`{a} la ligne 469 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert2(), decl\-Manager, CDecl\-Manager::free\-Symbol(), CSymbol::get\-Id(), INSTR\_\-EQL, instr\-Queue, CSymbol::is\-Valid(), CInstr\-Queue::push\-Instr(), et T\_\-BOOL.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=231pt]{process_8h_409097c2fa8f126d3d71a4c500cbce1a_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processGoto@{processGoto}}
\index{processGoto@{processGoto}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-Goto ({\bf Label\-Id} {\em id})}\label{process_8h_cfd828f2940972a16d8027e372284d74}


Ajoute un goto vers une \'{e}tiquette donn\'{e}e. 



D\'{e}finition \`{a} la ligne 777 du fichier process.cpp.

R\'{e}f\'{e}rences INSTR\_\-GOTO, instr\-Queue, et CInstr\-Queue::push\-Instr().

R\'{e}f\'{e}renc\'{e} par process\-Goto\-New(), process\-Repeat\-Until\-End(), et process\-While\-Do\-End().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=133pt]{process_8h_cfd828f2940972a16d8027e372284d74_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processGotoNew@{processGotoNew}}
\index{processGotoNew@{processGotoNew}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-Goto\-New ()}\label{process_8h_ba9f7c27657838cdecc5091b45c26b4b}


Ajoute un goto vers une nouvelle \'{e}tiquette et la retourne. 



D\'{e}finition \`{a} la ligne 772 du fichier process.cpp.

R\'{e}f\'{e}rences instr\-Queue, process\-Goto(), et CInstr\-Queue::push\-New\-Label\-Id().

R\'{e}f\'{e}renc\'{e} par process\-Else(), et yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=238pt]{process_8h_ba9f7c27657838cdecc5091b45c26b4b_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processGrt@{processGrt}}
\index{processGrt@{processGrt}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Grt ({\bf CSymbol} $\ast$ {\em s1}, {\bf CSymbol} $\ast$ {\em s2})}\label{process_8h_811edf033797b3b264c8f7677b668cd5}


Calcule s1 $>$ s2. 



D\'{e}finition \`{a} la ligne 509 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert2(), decl\-Manager, CDecl\-Manager::free\-Symbol(), CSymbol::get\-Id(), INSTR\_\-GRT, instr\-Queue, CSymbol::is\-Valid(), CInstr\-Queue::push\-Instr(), et T\_\-BOOL.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=231pt]{process_8h_811edf033797b3b264c8f7677b668cd5_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processId@{processId}}
\index{processId@{processId}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Id ({\bf Str\-Id} {\em id})}\label{process_8h_75253b73bb6d4214255233149027f723}


Retourne le symbole associ\'{e} \`{a} un id, g\`{e}re les erreurs. 



D\'{e}finition \`{a} la ligne 98 du fichier process.cpp.

R\'{e}f\'{e}rences ERR\_\-UNDECLARED, error\-Error(), CSymbol\-Stack::get\-Symbol\-From\-Str\-Id(), et symbol\-Stack.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=156pt]{process_8h_75253b73bb6d4214255233149027f723_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processIfNot@{processIfNot}}
\index{processIfNot@{processIfNot}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-If\-Not ({\bf CSymbol} $\ast$ {\em s})}\label{process_8h_6d3e9be70999af225c74a57fefc5b6bc}


Ajoute un branchement conditionnel IFNOT en testant s. 



D\'{e}finition \`{a} la ligne 782 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::get\-Id(), INSTR\_\-IFNOT, instr\-Queue, et CInstr\-Queue::push\-Instr().

R\'{e}f\'{e}renc\'{e} par process\-Repeat\-Until\-End(), et yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=133pt]{process_8h_6d3e9be70999af225c74a57fefc5b6bc_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processLabel@{processLabel}}
\index{processLabel@{processLabel}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-Label ({\bf Label\-Id} {\em id})}\label{process_8h_e13e13105a70b3e765ba10c3112fdd8b}


Ajoute un label vers une \'{e}tiquette donn\'{e}e. 



D\'{e}finition \`{a} la ligne 767 du fichier process.cpp.

R\'{e}f\'{e}rences INSTR\_\-LABEL, instr\-Queue, et CInstr\-Queue::push\-Instr().

R\'{e}f\'{e}renc\'{e} par process\-Cond\-End(), process\-Else(), process\-Label\-New(), et process\-While\-Do\-End().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=134pt]{process_8h_e13e13105a70b3e765ba10c3112fdd8b_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processLabelNew@{processLabelNew}}
\index{processLabelNew@{processLabelNew}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-Label\-New ()}\label{process_8h_be3022fc72f142a26c118f5fae5ae257}


Ajoute un label vers une nouvelle \'{e}tiquette et la retourne. 



D\'{e}finition \`{a} la ligne 762 du fichier process.cpp.

R\'{e}f\'{e}rences instr\-Queue, process\-Label(), et CInstr\-Queue::push\-New\-Label\-Id().

R\'{e}f\'{e}renc\'{e} par process\-Loop\-Start().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=239pt]{process_8h_be3022fc72f142a26c118f5fae5ae257_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processLoopStart@{processLoopStart}}
\index{processLoopStart@{processLoopStart}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-Loop\-Start ()}\label{process_8h_6ba943668971242bdd394d88a27e8b80}


Ajoute les instructions pour un d\'{e}but de boucle (WHILE/REPEAT). 



D\'{e}finition \`{a} la ligne 801 du fichier process.cpp.

R\'{e}f\'{e}rences process\-Label\-New().

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=305pt]{process_8h_6ba943668971242bdd394d88a27e8b80_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processLow@{processLow}}
\index{processLow@{processLow}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Low ({\bf CSymbol} $\ast$ {\em s1}, {\bf CSymbol} $\ast$ {\em s2})}\label{process_8h_cff7a0f36914dc1b8691319da60f15ef}


Calcule s1 $<$ s2. 



D\'{e}finition \`{a} la ligne 549 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert2(), decl\-Manager, CDecl\-Manager::free\-Symbol(), CSymbol::get\-Id(), INSTR\_\-LOW, instr\-Queue, CSymbol::is\-Valid(), CInstr\-Queue::push\-Instr(), et T\_\-BOOL.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=233pt]{process_8h_cff7a0f36914dc1b8691319da60f15ef_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processMinus@{processMinus}}
\index{processMinus@{processMinus}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Minus ({\bf CSymbol} $\ast$ {\em s})}\label{process_8h_9aca9d74bcc2052741c0977fc2bc068a}


Calcule l'oppos\'{e} d'un symbole. 



D\'{e}finition \`{a} la ligne 690 du fichier process.cpp.

R\'{e}f\'{e}rences CType::get\-Base(), CSymbol::get\-Type(), process\-Const\-Bool(), process\-Const\-Float(), process\-Const\-Int(), T\_\-BOOL, T\_\-FLOAT, et T\_\-INT.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=203pt]{process_8h_9aca9d74bcc2052741c0977fc2bc068a_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processMul@{processMul}}
\index{processMul@{processMul}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Mul ({\bf CSymbol} $\ast$ {\em s1}, {\bf CSymbol} $\ast$ {\em s2})}\label{process_8h_57a6856394ce98ca44abf5783b5a0720}


Multiplie s1 par s2. 



D\'{e}finition \`{a} la ligne 363 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert2(), decl\-Manager, ERR\_\-OP\_\-UNCOMPATIBLE, error\-Error(), CDecl\-Manager::free\-Symbol(), CType::get\-DRef(), CSymbol::get\-Id(), CSymbol::get\-Type(), INSTR\_\-MUL, instr\-Queue, CSymbol::is\-Valid(), et CInstr\-Queue::push\-Instr().

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=232pt]{process_8h_57a6856394ce98ca44abf5783b5a0720_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processNeq@{processNeq}}
\index{processNeq@{processNeq}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Neq ({\bf CSymbol} $\ast$ {\em s1}, {\bf CSymbol} $\ast$ {\em s2})}\label{process_8h_f550d569d60e44dcdb9e499672a14bea}


Calcule s1 != s2. 



D\'{e}finition \`{a} la ligne 589 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert2(), decl\-Manager, CDecl\-Manager::free\-Symbol(), CSymbol::get\-Id(), INSTR\_\-NEQ, instr\-Queue, CSymbol::is\-Valid(), CInstr\-Queue::push\-Instr(), et T\_\-BOOL.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=233pt]{process_8h_f550d569d60e44dcdb9e499672a14bea_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processNot@{processNot}}
\index{processNot@{processNot}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Not ({\bf CSymbol} $\ast$ {\em s})}\label{process_8h_67fcd60128f43e10ce9db73e7f9dbf40}


Calcule la n\'{e}gation d'un symbole. 



D\'{e}finition \`{a} la ligne 710 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert(), decl\-Manager, CDecl\-Manager::free\-Symbol(), CSymbol::is\-Valid(), et T\_\-BOOL.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=232pt]{process_8h_67fcd60128f43e10ce9db73e7f9dbf40_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processOp1And@{processOp1And}}
\index{processOp1And@{processOp1And}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Op1And ({\bf CSymbol} $\ast$ {\em s})}\label{process_8h_927c99a0324a391f1fd01a5bff85d98a}


\char`\"{}Et\char`\"{} paresseux, traitement du premier op\'{e}rande 

La fonction retourne le symbole cible dans lequel sera contenu le r\'{e}sultat du et. Ce symbole sera utilis\'{e} par la fonction appell\'{e}e apr\`{e}s la lecture du deuxi\`{e}me op\'{e}rande. 

D\'{e}finition \`{a} la ligne 170 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert(), decl\-Manager, CDecl\-Manager::free\-Symbol(), CSymbol::is\-Valid(), et T\_\-BOOL.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=242pt]{process_8h_927c99a0324a391f1fd01a5bff85d98a_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processOp1Or@{processOp1Or}}
\index{processOp1Or@{processOp1Or}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Op1Or ({\bf CSymbol} $\ast$ {\em s})}\label{process_8h_bb117e3019f3dab519228757645569bb}


\char`\"{}Ou\char`\"{} paresseux, traitement du premier op\'{e}rande 

La fonction retourne le symbole cible dans lequel sera contenu le r\'{e}sultat du ou. Ce symbole sera utilis\'{e} par la fonction appell\'{e}e apr\`{e}s la lecture du deuxi\`{e}me op\'{e}rande. 

D\'{e}finition \`{a} la ligne 110 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert(), decl\-Manager, CDecl\-Manager::free\-Symbol(), CSymbol::is\-Valid(), et T\_\-BOOL.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=239pt]{process_8h_bb117e3019f3dab519228757645569bb_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processOp2And@{processOp2And}}
\index{processOp2And@{processOp2And}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Op2And ({\bf CSymbol} $\ast$ {\em scible}, {\bf CSymbol} $\ast$ {\em s})}\label{process_8h_15a8373ba0318e4a5c91c13c1dacd57a}


\char`\"{}Et\char`\"{} paresseux, traitement du deuxi\`{e}me op\'{e}rande 



D\'{e}finition \`{a} la ligne 204 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert(), decl\-Manager, CDecl\-Manager::free\-Symbol(), CSymbol::is\-Valid(), et T\_\-BOOL.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=242pt]{process_8h_15a8373ba0318e4a5c91c13c1dacd57a_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processOp2Or@{processOp2Or}}
\index{processOp2Or@{processOp2Or}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Op2Or ({\bf CSymbol} $\ast$ {\em scible}, {\bf CSymbol} $\ast$ {\em s})}\label{process_8h_2e32acb505592e654093adfe518b0bbe}


\char`\"{}Ou\char`\"{} paresseux, traitement du deuxi\`{e}me op\'{e}rande 



D\'{e}finition \`{a} la ligne 144 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert(), decl\-Manager, CDecl\-Manager::free\-Symbol(), CSymbol::is\-Valid(), et T\_\-BOOL.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=239pt]{process_8h_2e32acb505592e654093adfe518b0bbe_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processRef@{processRef}}
\index{processRef@{processRef}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Ref ({\bf Str\-Id} {\em id})}\label{process_8h_3405314f33cffd2ad4a306a7f455aa06}


D\'{e}r\'{e}f\'{e}rence un symbole. 



D\'{e}finition \`{a} la ligne 631 du fichier process.cpp.

R\'{e}f\'{e}rences decl\-Manager, CDecl\-Manager::free\-Symbol(), CSymbol::get\-Id(), CSymbol\-Stack::get\-Symbol\-From\-Str\-Id(), CSymbol::get\-Type(), INSTR\_\-REF, instr\-Queue, CInstr\-Queue::push\-Instr(), CType::ref(), et symbol\-Stack.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=252pt]{process_8h_3405314f33cffd2ad4a306a7f455aa06_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processRefAff@{processRefAff}}
\index{processRefAff@{processRefAff}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-Ref\-Aff ({\bf CSymbol} $\ast$ {\em ref}, {\bf CSymbol} $\ast$ {\em val})}\label{process_8h_b56c4f8b83e03f46c4edea89d8500f2d}


Affectation d'une variable par r\'{e}f\'{e}rence. 



D\'{e}finition \`{a} la ligne 58 du fichier process.cpp.

R\'{e}f\'{e}rences decl\-Manager, ERR\_\-REFAFF\_\-REF, error\-Error(), CDecl\-Manager::free\-Symbol(), CType::get\-DRef(), et CSymbol::get\-Type().

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=238pt]{process_8h_b56c4f8b83e03f46c4edea89d8500f2d_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processRepeatUntilEnd@{processRepeatUntilEnd}}
\index{processRepeatUntilEnd@{processRepeatUntilEnd}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-Repeat\-Until\-End ({\bf CSymbol} $\ast$ {\em s})}\label{process_8h_57c0a2d1f11eb90eb5fbcefb05a6a1d3}


Ajoute les instructions de fin de REPEAT UNTIL. 



D\'{e}finition \`{a} la ligne 817 du fichier process.cpp.

R\'{e}f\'{e}rences instr\-Queue, CInstr\-Queue::pop\-Label\-Id(), process\-Goto(), et process\-If\-Not().

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=239pt]{process_8h_57c0a2d1f11eb90eb5fbcefb05a6a1d3_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processSub@{processSub}}
\index{processSub@{processSub}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf CSymbol}$\ast$ process\-Sub ({\bf CSymbol} $\ast$ {\em s1}, {\bf CSymbol} $\ast$ {\em s2})}\label{process_8h_7111e96d8f35172eb40a54b78ff285df}


Soustrait s2 \`{a} s1. 



D\'{e}finition \`{a} la ligne 298 du fichier process.cpp.

R\'{e}f\'{e}rences CSymbol::convert(), CSymbol::convert2(), decl\-Manager, error\-Warning(), CDecl\-Manager::free\-Symbol(), CType::get\-DRef(), CSymbol::get\-Type(), et T\_\-INT.

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=233pt]{process_8h_7111e96d8f35172eb40a54b78ff285df_cgraph}
\end{center}
\end{figure}
\index{process.h@{process.h}!processWhileDoEnd@{processWhileDoEnd}}
\index{processWhileDoEnd@{processWhileDoEnd}!process.h@{process.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void process\-While\-Do\-End ()}\label{process_8h_56c49b39f5a512ba91a2b41365cecc74}


Ajoute ;es innstructions de fin de WHILE DO. 



D\'{e}finition \`{a} la ligne 806 du fichier process.cpp.

R\'{e}f\'{e}rences instr\-Queue, CInstr\-Queue::pop\-Label\-Id(), process\-Goto(), et process\-Label().

R\'{e}f\'{e}renc\'{e} par yyparse().

Voici le graphe d'appel pour cette fonction:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=232pt]{process_8h_56c49b39f5a512ba91a2b41365cecc74_cgraph}
\end{center}
\end{figure}
